/*
 * tree234.c: reasonably generic counted 2-3-4 tree routines.
 *
 * This file is copyright 1999-2001 Simon Tatham.
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without
 * restriction, including without limitation the rights to use,
 * copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following
 * conditions:
 *
 * The above copyright notice and this permission notice shall be
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT.  IN NO EVENT SHALL SIMON TATHAM BE LIABLE FOR
 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>

#include "tree234.h"

#ifdef TEST
#define LOG(x) (printf x)
#define snew(type) ((type *)malloc(sizeof(type)))
#define snewn(n, type) ((type *)malloc((n) * sizeof(type)))
#define sresize(ptr, n, type)                                                  \
  ((type *)realloc(sizeof((type *)0 == (ptr)) ? (ptr) : (ptr),                 \
                   (n) * sizeof(type)))
#define sfree(ptr) free(ptr)
#else
#include "puttymem.h"
#define LOG(x)
#endif

typedef struct node234_Tag node234;

struct tree234_Tag {
  node234 *root;
  cmpfn234 cmp;
};

struct node234_Tag {
  node234 *parent;
  node234 *kids[4];
  int counts[4];
  void *elems[3];
};

/*
 * Create a 2-3-4 tree.
 */
tree234 *newtree234(cmpfn234 cmp)
{
  tree234 *ret = snew(tree234);
  LOG(("created tree %p\n", ret));
  ret->root = NULL;
  ret->cmp = cmp;
  return ret;
}

/*
 * Free a 2-3-4 tree (not including freeing the elements).
 */
static void freenode234(node234 *n)
{
  if (!n)
    return;
  freenode234(n->kids[0]);
  freenode234(n->kids[1]);
  freenode234(n->kids[2]);
  freenode234(n->kids[3]);
  sfree(n);
}

void freetree234(tree234 *t)
{
  freenode234(t->root);
  sfree(t);
}

/*
 * Internal function to count a node.
 */
static int countnode234(node234 *n)
{
  int count = 0;
  int i;
  if (!n)
    return 0;
  for (i = 0; i < 4; i++)
    count += n->counts[i];
  for (i = 0; i < 3; i++)
    if (n->elems[i])
      count++;
  return count;
}

/*
 * Count the elements in a tree.
 */
int count234(tree234 *t)
{
  if (t->root)
    return countnode234(t->root);
  else
    return 0;
}

/*
 * Add an element e to a 2-3-4 tree t. Returns e on success, or if
 * an existing element compares equal, returns that.
 */
static void *add234_internal(tree234 *t, void *e, int index)
{
  node234 *n, **np, *left, *right;
  void *orig_e = e;
  int c, lcount, rcount;

  LOG(("adding node %p to tree %p\n", e, t));
  if (t->root == NULL) {
    t->root = snew(node234);
    t->root->elems[1] = t->root->elems[2] = NULL;
    t->root->kids[0] = t->root->kids[1] = NULL;
    t->root->kids[2] = t->root->kids[3] = NULL;
    t->root->counts[0] = t->root->counts[1] = 0;
    t->root->counts[2] = t->root->counts[3] = 0;
    t->root->parent = NULL;
    t->root->elems[0] = e;
    LOG(("  created root %p\n", t->root));
    return orig_e;
  }

  n = NULL; /* placate gcc; will always be set below since t->root != NULL */
  np = &t->root;
  while (*np) {
    int childnum;
    n = *np;
    LOG(("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",
         n,
         n->kids[0],
         n->counts[0],
         n->elems[0],
         n->kids[1],
         n->counts[1],
         n->elems[1],
         n->kids[2],
         n->counts[2],
         n->elems[2],
         n->kids[3],
         n->counts[3]));
    if (index >= 0) {
      if (!n->kids[0]) {
        /*
         * Leaf node. We want to insert at kid position
         * equal to the index:
         *
         *   0 A 1 B 2 C 3
         */
        childnum = index;
      } else {
        /*
         * Internal node. We always descend through it (add
         * always starts at the bottom, never in the
         * middle).
         */
        do { /* this is a do ... while (0) to allow `break' */
          if (index <= n->counts[0]) {
            childnum = 0;
            break;
          }
          index -= n->counts[0] + 1;
          if (index <= n->counts[1]) {
            childnum = 1;
            break;
          }
          index -= n->counts[1] + 1;
          if (index <= n->counts[2]) {
            childnum = 2;
            break;
          }
          index -= n->counts[2] + 1;
          if (index <= n->counts[3]) {
            childnum = 3;
            break;
          }
          return NULL; /* error: index out of range */
        } while (0);
      }
    } else {
      if ((c = t->cmp(e, n->elems[0])) < 0)
        childnum = 0;
      else if (c == 0)
        return n->elems[0]; /* already exists */
      else if (n->elems[1] == NULL || (c = t->cmp(e, n->elems[1])) < 0)
        childnum = 1;
      else if (c == 0)
        return n->elems[1]; /* already exists */
      else if (n->elems[2] == NULL || (c = t->cmp(e, n->elems[2])) < 0)
        childnum = 2;
      else if (c == 0)
        return n->elems[2]; /* already exists */
      else
        childnum = 3;
    }
    np = &n->kids[childnum];
    LOG(("  moving to child %d (%p)\n", childnum, *np));
  }

  /*
   * We need to insert the new element in n at position np.
   */
  left = NULL;
  lcount = 0;
  right = NULL;
  rcount = 0;
  while (n) {
    LOG(("  at %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d\n",
         n,
         n->kids[0],
         n->counts[0],
         n->elems[0],
         n->kids[1],
         n->counts[1],
         n->elems[1],
         n->kids[2],
         n->counts[2],
         n->elems[2],
         n->kids[3],
         n->counts[3]));
    LOG(("  need to insert %p/%d [%p] %p/%d at position %d\n",
         left,
         lcount,
         e,
         right,
         rcount,
         (int)(np - n->kids)));
    if (n->elems[1] == NULL) {
      /*
       * Insert in a 2-node; simple.
       */
      if (np == &n->kids[0]) {
        LOG(("  inserting on left of 2-node\n"));
        n->kids[2] = n->kids[1];
        n->counts[2] = n->counts[1];
        n->elems[1] = n->elems[0];
        n->kids[1] = right;
        n->counts[1] = rcount;
        n->elems[0] = e;
        n->kids[0] = left;
        n->counts[0] = lcount;
      } else { /* np == &n->kids[1] */
        LOG(("  inserting on right of 2-node\n"));
        n->kids[2] = right;
        n->counts[2] = rcount;
        n->elems[1] = e;
        n->kids[1] = left;
        n->counts[1] = lcount;
      }
      if (n->kids[0])
        n->kids[0]->parent = n;
      if (n->kids[1])
        n->kids[1]->parent = n;
      if (n->kids[2])
        n->kids[2]->parent = n;
      LOG(("  done\n"));
      break;
    } else if (n->elems[2] == NULL) {
      /*
       * Insert in a 3-node; simple.
       */
      if (np == &n->kids[0]) {
        LOG(("  inserting on left of 3-node\n"));
        n->kids[3] = n->kids[2];
        n->counts[3] = n->counts[2];
        n->elems[2] = n->elems[1];
        n->kids[2] = n->kids[1];
        n->counts[2] = n->counts[1];
        n->elems[1] = n->elems[0];
        n->kids[1] = right;
        n->counts[1] = rcount;
        n->elems[0] = e;
        n->kids[0] = left;
        n->counts[0] = lcount;
      } else if (np == &n->kids[1]) {
        LOG(("  inserting in middle of 3-node\n"));
        n->kids[3] = n->kids[2];
        n->counts[3] = n->counts[2];
        n->elems[2] = n->elems[1];
        n->kids[2] = right;
        n->counts[2] = rcount;
        n->elems[1] = e;
        n->kids[1] = left;
        n->counts[1] = lcount;
      } else { /* np == &n->kids[2] */
        LOG(("  inserting on right of 3-node\n"));
        n->kids[3] = right;
        n->counts[3] = rcount;
        n->elems[2] = e;
        n->kids[2] = left;
        n->counts[2] = lcount;
      }
      if (n->kids[0])
        n->kids[0]->parent = n;
      if (n->kids[1])
        n->kids[1]->parent = n;
      if (n->kids[2])
        n->kids[2]->parent = n;
      if (n->kids[3])
        n->kids[3]->parent = n;
      LOG(("  done\n"));
      break;
    } else {
      node234 *m = snew(node234);
      m->parent = n->parent;
      LOG(("  splitting a 4-node; created new node %p\n", m));
      /*
       * Insert in a 4-node; split into a 2-node and a
       * 3-node, and move focus up a level.
       *
       * I don't think it matters which way round we put the
       * 2 and the 3. For simplicity, we'll put the 3 first
       * always.
       */
      if (np == &n->kids[0]) {
        m->kids[0] = left;
        m->counts[0] = lcount;
        m->elems[0] = e;
        m->kids[1] = right;
        m->counts[1] = rcount;
        m->elems[1] = n->elems[0];
        m->kids[2] = n->kids[1];
        m->counts[2] = n->counts[1];
        e = n->elems[1];
        n->kids[0] = n->kids[2];
        n->counts[0] = n->counts[2];
        n->elems[0] = n->elems[2];
        n->kids[1] = n->kids[3];
        n->counts[1] = n->counts[3];
      } else if (np == &n->kids[1]) {
        m->kids[0] = n->kids[0];
        m->counts[0] = n->counts[0];
        m->elems[0] = n->elems[0];
        m->kids[1] = left;
        m->counts[1] = lcount;
        m->elems[1] = e;
        m->kids[2] = right;
        m->counts[2] = rcount;
        e = n->elems[1];
        n->kids[0] = n->kids[2];
        n->counts[0] = n->counts[2];
        n->elems[0] = n->elems[2];
        n->kids[1] = n->kids[3];
        n->counts[1] = n->counts[3];
      } else if (np == &n->kids[2]) {
        m->kids[0] = n->kids[0];
        m->counts[0] = n->counts[0];
        m->elems[0] = n->elems[0];
        m->kids[1] = n->kids[1];
        m->counts[1] = n->counts[1];
        m->elems[1] = n->elems[1];
        m->kids[2] = left;
        m->counts[2] = lcount;
        /* e = e; */
        n->kids[0] = right;
        n->counts[0] = rcount;
        n->elems[0] = n->elems[2];
        n->kids[1] = n->kids[3];
        n->counts[1] = n->counts[3];
      } else { /* np == &n->kids[3] */
        m->kids[0] = n->kids[0];
        m->counts[0] = n->counts[0];
        m->elems[0] = n->elems[0];
        m->kids[1] = n->kids[1];
        m->counts[1] = n->counts[1];
        m->elems[1] = n->elems[1];
        m->kids[2] = n->kids[2];
        m->counts[2] = n->counts[2];
        n->kids[0] = left;
        n->counts[0] = lcount;
        n->elems[0] = e;
        n->kids[1] = right;
        n->counts[1] = rcount;
        e = n->elems[2];
      }
      m->kids[3] = n->kids[3] = n->kids[2] = NULL;
      m->counts[3] = n->counts[3] = n->counts[2] = 0;
      m->elems[2] = n->elems[2] = n->elems[1] = NULL;
      if (m->kids[0])
        m->kids[0]->parent = m;
      if (m->kids[1])
        m->kids[1]->parent = m;
      if (m->kids[2])
        m->kids[2]->parent = m;
      if (n->kids[0])
        n->kids[0]->parent = n;
      if (n->kids[1])
        n->kids[1]->parent = n;
      LOG(("  left (%p): %p/%d [%p] %p/%d [%p] %p/%d\n",
           m,
           m->kids[0],
           m->counts[0],
           m->elems[0],
           m->kids[1],
           m->counts[1],
           m->elems[1],
           m->kids[2],
           m->counts[2]));
      LOG(("  right (%p): %p/%d [%p] %p/%d\n",
           n,
           n->kids[0],
           n->counts[0],
           n->elems[0],
           n->kids[1],
           n->counts[1]));
      left = m;
      lcount = countnode234(left);
      right = n;
      rcount = countnode234(right);
    }
    if (n->parent)
      np = (n->parent->kids[0] == n
                ? &n->parent->kids[0]
                : n->parent->kids[1] == n
                      ? &n->parent->kids[1]
                      : n->parent->kids[2] == n ? &n->parent->kids[2]
                                                : &n->parent->kids[3]);
    n = n->parent;
  }

  /*
   * If we've come out of here by `break', n will still be
   * non-NULL and all we need to do is go back up the tree
   * updating counts. If we've come here because n is NULL, we
   * need to create a new root for the tree because the old one
   * has just split into two. */
  if (n) {
    while (n->parent) {
      int count = countnode234(n);
      int childnum;
      childnum =
          (n->parent->kids[0] == n
               ? 0
               : n->parent->kids[1] == n ? 1 : n->parent->kids[2] == n ? 2 : 3);
      n->parent->counts[childnum] = count;
      n = n->parent;
    }
  } else {
    LOG(("  root is overloaded, split into two\n"));
    t->root = snew(node234);
    t->root->kids[0] = left;
    t->root->counts[0] = lcount;
    t->root->elems[0] = e;
    t->root->kids[1] = right;
    t->root->counts[1] = rcount;
    t->root->elems[1] = NULL;
    t->root->kids[2] = NULL;
    t->root->counts[2] = 0;
    t->root->elems[2] = NULL;
    t->root->kids[3] = NULL;
    t->root->counts[3] = 0;
    t->root->parent = NULL;
    if (t->root->kids[0])
      t->root->kids[0]->parent = t->root;
    if (t->root->kids[1])
      t->root->kids[1]->parent = t->root;
    LOG(("  new root is %p/%d [%p] %p/%d\n",
         t->root->kids[0],
         t->root->counts[0],
         t->root->elems[0],
         t->root->kids[1],
         t->root->counts[1]));
  }

  return orig_e;
}

void *add234(tree234 *t, void *e)
{
  if (!t->cmp) /* tree is unsorted */
    return NULL;

  return add234_internal(t, e, -1);
}
void *addpos234(tree234 *t, void *e, int index)
{
  if (index < 0 || /* index out of range */
      t->cmp)      /* tree is sorted */
    return NULL;   /* return failure */

  return add234_internal(t, e, index); /* this checks the upper bound */
}

/*
 * Look up the element at a given numeric index in a 2-3-4 tree.
 * Returns NULL if the index is out of range.
 */
void *index234(tree234 *t, int index)
{
  node234 *n;

  if (!t->root)
    return NULL; /* tree is empty */

  if (index < 0 || index >= countnode234(t->root))
    return NULL; /* out of range */

  n = t->root;

  while (n) {
    if (index < n->counts[0])
      n = n->kids[0];
    else if (index -= n->counts[0] + 1, index < 0)
      return n->elems[0];
    else if (index < n->counts[1])
      n = n->kids[1];
    else if (index -= n->counts[1] + 1, index < 0)
      return n->elems[1];
    else if (index < n->counts[2])
      n = n->kids[2];
    else if (index -= n->counts[2] + 1, index < 0)
      return n->elems[2];
    else
      n = n->kids[3];
  }

  /* We shouldn't ever get here. I wonder how we did. */
  return NULL;
}

/*
 * Find an element e in a sorted 2-3-4 tree t. Returns NULL if not
 * found. e is always passed as the first argument to cmp, so cmp
 * can be an asymmetric function if desired. cmp can also be passed
 * as NULL, in which case the compare function from the tree proper
 * will be used.
 */
void *findrelpos234(tree234 *t, void *e, cmpfn234 cmp, int relation, int *index)
{
  node234 *n;
  void *ret;
  int c;
  int idx, ecount, kcount, cmpret;

  if (t->root == NULL)
    return NULL;

  if (cmp == NULL)
    cmp = t->cmp;

  n = t->root;
  /*
   * Attempt to find the element itself.
   */
  idx = 0;
  ecount = -1;
  /*
   * Prepare a fake `cmp' result if e is NULL.
   */
  cmpret = 0;
  if (e == NULL) {
    assert(relation == REL234_LT || relation == REL234_GT);
    if (relation == REL234_LT)
      cmpret = +1; /* e is a max: always greater */
    else if (relation == REL234_GT)
      cmpret = -1; /* e is a min: always smaller */
  }
  while (1) {
    for (kcount = 0; kcount < 4; kcount++) {
      if (kcount >= 3 || n->elems[kcount] == NULL ||
          (c = cmpret ? cmpret : cmp(e, n->elems[kcount])) < 0) {
        break;
      }
      if (n->kids[kcount])
        idx += n->counts[kcount];
      if (c == 0) {
        ecount = kcount;
        break;
      }
      idx++;
    }
    if (ecount >= 0)
      break;
    if (n->kids[kcount])
      n = n->kids[kcount];
    else
      break;
  }

  if (ecount >= 0) {
    /*
     * We have found the element we're looking for. It's
     * n->elems[ecount], at tree index idx. If our search
     * relation is EQ, LE or GE we can now go home.
     */
    if (relation != REL234_LT && relation != REL234_GT) {
      if (index)
        *index = idx;
      return n->elems[ecount];
    }

    /*
     * Otherwise, we'll do an indexed lookup for the previous
     * or next element. (It would be perfectly possible to
     * implement these search types in a non-counted tree by
     * going back up from where we are, but far more fiddly.)
     */
    if (relation == REL234_LT)
      idx--;
    else
      idx++;
  } else {
    /*
     * We've found our way to the bottom of the tree and we
     * know where we would insert this node if we wanted to:
     * we'd put it in in place of the (empty) subtree
     * n->kids[kcount], and it would have index idx
     *
     * But the actual element isn't there. So if our search
     * relation is EQ, we're doomed.
     */
    if (relation == REL234_EQ)
      return NULL;

    /*
     * Otherwise, we must do an index lookup for index idx-1
     * (if we're going left - LE or LT) or index idx (if we're
     * going right - GE or GT).
     */
    if (relation == REL234_LT || relation == REL234_LE) {
      idx--;
    }
  }

  /*
   * We know the index of the element we want; just call index234
   * to do the rest. This will return NULL if the index is out of
   * bounds, which is exactly what we want.
   */
  ret = index234(t, idx);
  if (ret && index)
    *index = idx;
  return ret;
}
void *find234(tree234 *t, void *e, cmpfn234 cmp)
{
  return findrelpos234(t, e, cmp, REL234_EQ, NULL);
}
void *findrel234(tree234 *t, void *e, cmpfn234 cmp, int relation)
{
  return findrelpos234(t, e, cmp, relation, NULL);
}
void *findpos234(tree234 *t, void *e, cmpfn234 cmp, int *index)
{
  return findrelpos234(t, e, cmp, REL234_EQ, index);
}

/*
 * Delete an element e in a 2-3-4 tree. Does not free the element,
 * merely removes all links to it from the tree nodes.
 */
static void *delpos234_internal(tree234 *t, int index)
{
  node234 *n;
  void *retval;
  int ei = -1;

  retval = 0;

  n = t->root;
  LOG(("deleting item %d from tree %p\n", index, t));
  while (1) {
    while (n) {
      int ki;
      node234 *sub;

      LOG(("  node %p: %p/%d [%p] %p/%d [%p] %p/%d [%p] %p/%d index=%d\n",
           n,
           n->kids[0],
           n->counts[0],
           n->elems[0],
           n->kids[1],
           n->counts[1],
           n->elems[1],
           n->kids[2],
           n->counts[2],
           n->elems[2],
           n->kids[3],
           n->counts[3],
           index));
      if (index < n->counts[0]) {
        ki = 0;
      } else if (index -= n->counts[0] + 1, index < 0) {
        ei = 0;
        break;
      } else if (index < n->counts[1]) {
        ki = 1;
      } else if (index -= n->counts[1] + 1, index < 0) {
        ei = 1;
        break;
      } else if (index < n->counts[2]) {
        ki = 2;
      } else if (index -= n->counts[2] + 1, index < 0) {
        ei = 2;
        break;
      } else {
        ki = 3;
      }
      /*
       * Recurse down to subtree ki. If it has only one element,
       * we have to do some transformation to start with.
       */
      LOG(("  moving to subtree %d\n", ki));
      sub = n->kids[ki];
      if (!sub->elems[1]) {
        LOG(("  subtree has only one element!\n"));
        if (ki > 0 && n->kids[ki - 1]->elems[1]) {
          /*
           * Case 3a, left-handed variant. Child ki has
           * only one element, but child ki-1 has two or
           * more. So we need to move a subtree from ki-1
           * to ki.
           *
           *                . C .                     . B .
           *               /     \     ->            /     \
           * [more] a A b B c   d D e      [more] a A b   c C d D e
           */
          node234 *sib = n->kids[ki - 1];
          int lastelem = (sib->elems[2] ? 2 : sib->elems[1] ? 1 : 0);
          sub->kids[2] = sub->kids[1];
          sub->counts[2] = sub->counts[1];
          sub->elems[1] = sub->elems[0];
          sub->kids[1] = sub->kids[0];
          sub->counts[1] = sub->counts[0];
          sub->elems[0] = n->elems[ki - 1];
          sub->kids[0] = sib->kids[lastelem + 1];
          sub->counts[0] = sib->counts[lastelem + 1];
          if (sub->kids[0])
            sub->kids[0]->parent = sub;
          n->elems[ki - 1] = sib->elems[lastelem];
          sib->kids[lastelem + 1] = NULL;
          sib->counts[lastelem + 1] = 0;
          sib->elems[lastelem] = NULL;
          n->counts[ki] = countnode234(sub);
          LOG(("  case 3a left\n"));
          LOG(("  index and left subtree count before adjustment: %d, %d\n",
               index,
               n->counts[ki - 1]));
          index += n->counts[ki - 1];
          n->counts[ki - 1] = countnode234(sib);
          index -= n->counts[ki - 1];
          LOG(("  index and left subtree count after adjustment: %d, %d\n",
               index,
               n->counts[ki - 1]));
        } else if (ki < 3 && n->kids[ki + 1] && n->kids[ki + 1]->elems[1]) {
          /*
           * Case 3a, right-handed variant. ki has only
           * one element but ki+1 has two or more. Move a
           * subtree from ki+1 to ki.
           *
           *      . B .                             . C .
           *     /     \                ->         /     \
           *  a A b   c C d D e [more]      a A b B c   d D e [more]
           */
          node234 *sib = n->kids[ki + 1];
          int j;
          sub->elems[1] = n->elems[ki];
          sub->kids[2] = sib->kids[0];
          sub->counts[2] = sib->counts[0];
          if (sub->kids[2])
            sub->kids[2]->parent = sub;
          n->elems[ki] = sib->elems[0];
          sib->kids[0] = sib->kids[1];
          sib->counts[0] = sib->counts[1];
          for (j = 0; j < 2 && sib->elems[j + 1]; j++) {
            sib->kids[j + 1] = sib->kids[j + 2];
            sib->counts[j + 1] = sib->counts[j + 2];
            sib->elems[j] = sib->elems[j + 1];
          }
          sib->kids[j + 1] = NULL;
          sib->counts[j + 1] = 0;
          sib->elems[j] = NULL;
          n->counts[ki] = countnode234(sub);
          n->counts[ki + 1] = countnode234(sib);
          LOG(("  case 3a right\n"));
        } else {
          /*
           * Case 3b. ki has only one element, and has no
           * neighbour with more than one. So pick a
           * neighbour and merge it with ki, taking an
           * element down from n to go in the middle.
           *
           *      . B .                .
           *     /     \     ->        |
           *  a A b   c C d      a A b B c C d
           *
           * (Since at all points we have avoided
           * descending to a node with only one element,
           * we can be sure that n is not reduced to
           * nothingness by this move, _unless_ it was
           * the very first node, ie the root of the
           * tree. In that case we remove the now-empty
           * root and replace it with its single large
           * child as shown.)
           */
          node234 *sib;
          int j;

          if (ki > 0) {
            ki--;
            index += n->counts[ki] + 1;
          }
          sib = n->kids[ki];
          sub = n->kids[ki + 1];

          sub->kids[3] = sub->kids[1];
          sub->counts[3] = sub->counts[1];
          sub->elems[2] = sub->elems[0];
          sub->kids[2] = sub->kids[0];
          sub->counts[2] = sub->counts[0];
          sub->elems[1] = n->elems[ki];
          sub->kids[1] = sib->kids[1];
          sub->counts[1] = sib->counts[1];
          if (sub->kids[1])
            sub->kids[1]->parent = sub;
          sub->elems[0] = sib->elems[0];
          sub->kids[0] = sib->kids[0];
          sub->counts[0] = sib->counts[0];
          if (sub->kids[0])
            sub->kids[0]->parent = sub;

          n->counts[ki + 1] = countnode234(sub);

          sfree(sib);

          /*
           * That's built the big node in sub. Now we
           * need to remove the reference to sib in n.
           */
          for (j = ki; j < 3 && n->kids[j + 1]; j++) {
            n->kids[j] = n->kids[j + 1];
            n->counts[j] = n->counts[j + 1];
            n->elems[j] = j < 2 ? n->elems[j + 1] : NULL;
          }
          n->kids[j] = NULL;
          n->counts[j] = 0;
          if (j < 3)
            n->elems[j] = NULL;
          LOG(("  case 3b ki=%d\n", ki));

          if (!n->elems[0]) {
            /*
             * The root is empty and needs to be
             * removed.
             */
            LOG(("  shifting root!\n"));
            t->root = sub;
            sub->parent = NULL;
            sfree(n);
          }
        }
      }
      n = sub;
    }
    if (!retval)
      retval = n->elems[ei];

    if (ei == -1)
      return NULL; /* although this shouldn't happen */

    /*
     * Treat special case: this is the one remaining item in
     * the tree. n is the tree root (no parent), has one
     * element (no elems[1]), and has no kids (no kids[0]).
     */
    if (!n->parent && !n->elems[1] && !n->kids[0]) {
      LOG(("  removed last element in tree\n"));
      sfree(n);
      t->root = NULL;
      return retval;
    }

    /*
     * Now we have the element we want, as n->elems[ei], and we
     * have also arranged for that element not to be the only
     * one in its node. So...
     */

    if (!n->kids[0] && n->elems[1]) {
      /*
       * Case 1. n is a leaf node with more than one element,
       * so it's _really easy_. Just delete the thing and
       * we're done.
       */
      int i;
      LOG(("  case 1\n"));
      for (i = ei; i < 2 && n->elems[i + 1]; i++)
        n->elems[i] = n->elems[i + 1];
      n->elems[i] = NULL;
      /*
       * Having done that to the leaf node, we now go back up
       * the tree fixing the counts.
       */
      while (n->parent) {
        int childnum;
        childnum =
            (n->parent->kids[0] == n
                 ? 0
                 : n->parent->kids[1] == n ? 1
                                           : n->parent->kids[2] == n ? 2 : 3);
        n->parent->counts[childnum]--;
        n = n->parent;
      }
      return retval; /* finished! */
    } else if (n->kids[ei]->elems[1]) {
      /*
       * Case 2a. n is an internal node, and the root of the
       * subtree to the left of e has more than one element.
       * So find the predecessor p to e (ie the largest node
       * in that subtree), place it where e currently is, and
       * then start the deletion process over again on the
       * subtree with p as target.
       */
      node234 *m = n->kids[ei];
      void *target;
      LOG(("  case 2a\n"));
      while (m->kids[0]) {
        m = (m->kids[3] ? m->kids[3]
                        : m->kids[2] ? m->kids[2]
                                     : m->kids[1] ? m->kids[1] : m->kids[0]);
      }
      target =
          (m->elems[2] ? m->elems[2] : m->elems[1] ? m->elems[1] : m->elems[0]);
      n->elems[ei] = target;
      index = n->counts[ei] - 1;
      n = n->kids[ei];
    } else if (n->kids[ei + 1]->elems[1]) {
      /*
       * Case 2b, symmetric to 2a but s/left/right/ and
       * s/predecessor/successor/. (And s/largest/smallest/).
       */
      node234 *m = n->kids[ei + 1];
      void *target;
      LOG(("  case 2b\n"));
      while (m->kids[0]) {
        m = m->kids[0];
      }
      target = m->elems[0];
      n->elems[ei] = target;
      n = n->kids[ei + 1];
      index = 0;
    } else {
      /*
       * Case 2c. n is an internal node, and the subtrees to
       * the left and right of e both have only one element.
       * So combine the two subnodes into a single big node
       * with their own elements on the left and right and e
       * in the middle, then restart the deletion process on
       * that subtree, with e still as target.
       */
      node234 *a = n->kids[ei], *b = n->kids[ei + 1];
      int j;

      LOG(("  case 2c\n"));
      a->elems[1] = n->elems[ei];
      a->kids[2] = b->kids[0];
      a->counts[2] = b->counts[0];
      if (a->kids[2])
        a->kids[2]->parent = a;
      a->elems[2] = b->elems[0];
      a->kids[3] = b->kids[1];
      a->counts[3] = b->counts[1];
      if (a->kids[3])
        a->kids[3]->parent = a;
      sfree(b);
      n->counts[ei] = countnode234(a);
      /*
       * That's built the big node in a, and destroyed b. Now
       * remove the reference to b (and e) in n.
       */
      for (j = ei; j < 2 && n->elems[j + 1]; j++) {
        n->elems[j] = n->elems[j + 1];
        n->kids[j + 1] = n->kids[j + 2];
        n->counts[j + 1] = n->counts[j + 2];
      }
      n->elems[j] = NULL;
      n->kids[j + 1] = NULL;
      n->counts[j + 1] = 0;
      /*
       * It's possible, in this case, that we've just removed
       * the only element in the root of the tree. If so,
       * shift the root.
       */
      if (n->elems[0] == NULL) {
        LOG(("  shifting root!\n"));
        t->root = a;
        a->parent = NULL;
        sfree(n);
      }
      /*
       * Now go round the deletion process again, with n
       * pointing at the new big node and e still the same.
       */
      n = a;
      index = a->counts[0] + a->counts[1] + 1;
    }
  }
}
void *delpos234(tree234 *t, int index)
{
  if (index < 0 || index >= countnode234(t->root))
    return NULL;
  return delpos234_internal(t, index);
}
void *del234(tree234 *t, void *e)
{
  int index;
  if (!findrelpos234(t, e, NULL, REL234_EQ, &index))
    return NULL;                       /* it wasn't in there anyway */
  return delpos234_internal(t, index); /* it's there; delete it. */
}

#ifdef TEST

/*
 * Test code for the 2-3-4 tree. This code maintains an alternative
 * representation of the data in the tree, in an array (using the
 * obvious and slow insert and delete functions). After each tree
 * operation, the verify() function is called, which ensures all
 * the tree properties are preserved:
 *  - node->child->parent always equals node
 *  - tree->root->parent always equals NULL
 *  - number of kids == 0 or number of elements + 1;
 *  - tree has the same depth everywhere
 *  - every node has at least one element
 *  - subtree element counts are accurate
 *  - any NULL kid pointer is accompanied by a zero count
 *  - in a sorted tree: ordering property between elements of a
 *    node and elements of its children is preserved
 * and also ensures the list represented by the tree is the same
 * list it should be. (This last check also doubly verifies the
 * ordering properties, because the `same list it should be' is by
 * definition correctly ordered. It also ensures all nodes are
 * distinct, because the enum functions would get caught in a loop
 * if not.)
 */

#include <stdarg.h>

/*
 * Error reporting function.
 */
void error(char *fmt, ...)
{
  va_list ap;
  printf("ERROR: ");
  va_start(ap, fmt);
  vfprintf(stdout, fmt, ap);
  va_end(ap);
  printf("\n");
}

/* The array representation of the data. */
void **array;
int arraylen, arraysize;
cmpfn234 cmp;

/* The tree representation of the same data. */
tree234 *tree;

typedef struct {
  int treedepth;
  int elemcount;
} chkctx;

int chknode(
    chkctx *ctx, int level, node234 *node, void *lowbound, void *highbound)
{
  int nkids, nelems;
  int i;
  int count;

  /* Count the non-NULL kids. */
  for (nkids = 0; nkids < 4 && node->kids[nkids]; nkids++)
    ;
  /* Ensure no kids beyond the first NULL are non-NULL. */
  for (i = nkids; i < 4; i++)
    if (node->kids[i]) {
      error("node %p: nkids=%d but kids[%d] non-NULL", node, nkids, i);
    } else if (node->counts[i]) {
      error("node %p: kids[%d] NULL but count[%d]=%d nonzero",
            node,
            i,
            i,
            node->counts[i]);
    }

  /* Count the non-NULL elements. */
  for (nelems = 0; nelems < 3 && node->elems[nelems]; nelems++)
    ;
  /* Ensure no elements beyond the first NULL are non-NULL. */
  for (i = nelems; i < 3; i++)
    if (node->elems[i]) {
      error("node %p: nelems=%d but elems[%d] non-NULL", node, nelems, i);
    }

  if (nkids == 0) {
    /*
     * If nkids==0, this is a leaf node; verify that the tree
     * depth is the same everywhere.
     */
    if (ctx->treedepth < 0)
      ctx->treedepth = level; /* we didn't know the depth yet */
    else if (ctx->treedepth != level)
      error("node %p: leaf at depth %d, previously seen depth %d",
            node,
            level,
            ctx->treedepth);
  } else {
    /*
     * If nkids != 0, then it should be nelems+1, unless nelems
     * is 0 in which case nkids should also be 0 (and so we
     * shouldn't be in this condition at all).
     */
    int shouldkids = (nelems ? nelems + 1 : 0);
    if (nkids != shouldkids) {
      error("node %p: %d elems should mean %d kids but has %d",
            node,
            nelems,
            shouldkids,
            nkids);
    }
  }

  /*
   * nelems should be at least 1.
   */
  if (nelems == 0) {
    error("node %p: no elems", node, nkids);
  }

  /*
   * Add nelems to the running element count of the whole tree.
   */
  ctx->elemcount += nelems;

  /*
   * Check ordering property: all elements should be strictly >
   * lowbound, strictly < highbound, and strictly < each other in
   * sequence. (lowbound and highbound are NULL at edges of tree
   * - both NULL at root node - and NULL is considered to be <
   * everything and > everything. IYSWIM.)
   */
  if (cmp) {
    for (i = -1; i < nelems; i++) {
      void *lower = (i == -1 ? lowbound : node->elems[i]);
      void *higher = (i + 1 == nelems ? highbound : node->elems[i + 1]);
      if (lower && higher && cmp(lower, higher) >= 0) {
        error("node %p: kid comparison [%d=%s,%d=%s] failed",
              node,
              i,
              lower,
              i + 1,
              higher);
      }
    }
  }

  /*
   * Check parent pointers: all non-NULL kids should have a
   * parent pointer coming back to this node.
   */
  for (i = 0; i < nkids; i++)
    if (node->kids[i]->parent != node) {
      error("node %p kid %d: parent ptr is %p not %p",
            node,
            i,
            node->kids[i]->parent,
            node);
    }

  /*
   * Now (finally!) recurse into subtrees.
   */
  count = nelems;

  for (i = 0; i < nkids; i++) {
    void *lower = (i == 0 ? lowbound : node->elems[i - 1]);
    void *higher = (i >= nelems ? highbound : node->elems[i]);
    int subcount = chknode(ctx, level + 1, node->kids[i], lower, higher);
    if (node->counts[i] != subcount) {
      error("node %p kid %d: count says %d, subtree really has %d",
            node,
            i,
            node->counts[i],
            subcount);
    }
    count += subcount;
  }

  return count;
}

void verify(void)
{
  chkctx ctx;
  int i;
  void *p;

  ctx.treedepth = -1; /* depth unknown yet */
  ctx.elemcount = 0;  /* no elements seen yet */
  /*
   * Verify validity of tree properties.
   */
  if (tree->root) {
    if (tree->root->parent != NULL)
      error("root->parent is %p should be null", tree->root->parent);
    chknode(&ctx, 0, tree->root, NULL, NULL);
  }
  printf("tree depth: %d\n", ctx.treedepth);
  /*
   * Enumerate the tree and ensure it matches up to the array.
   */
  for (i = 0; NULL != (p = index234(tree, i)); i++) {
    if (i >= arraylen)
      error("tree contains more than %d elements", arraylen);
    if (array[i] != p)
      error("enum at position %d: array says %s, tree says %s", i, array[i], p);
  }
  if (ctx.elemcount != i) {
    error("tree really contains %d elements, enum gave %d", ctx.elemcount, i);
  }
  if (i < arraylen) {
    error("enum gave only %d elements, array has %d", i, arraylen);
  }
  i = count234(tree);
  if (ctx.elemcount != i) {
    error(
        "tree really contains %d elements, count234 gave %d", ctx.elemcount, i);
  }
}

void internal_addtest(void *elem, int index, void *realret)
{
  int i, j;
  void *retval;

  if (arraysize < arraylen + 1) {
    arraysize = arraylen + 1 + 256;
    array = sresize(array, arraysize, void *);
  }

  i = index;
  /* now i points to the first element >= elem */
  retval = elem; /* expect elem returned (success) */
  for (j = arraylen; j > i; j--)
    array[j] = array[j - 1];
  array[i] = elem; /* add elem to array */
  arraylen++;

  if (realret != retval) {
    error("add: retval was %p expected %p", realret, retval);
  }

  verify();
}

void addtest(void *elem)
{
  int i;
  void *realret;

  realret = add234(tree, elem);

  i = 0;
  while (i < arraylen && cmp(elem, array[i]) > 0)
    i++;
  if (i < arraylen && !cmp(elem, array[i])) {
    void *retval = array[i]; /* expect that returned not elem */
    if (realret != retval) {
      error("add: retval was %p expected %p", realret, retval);
    }
  } else
    internal_addtest(elem, i, realret);
}

void addpostest(void *elem, int i)
{
  void *realret;

  realret = addpos234(tree, elem, i);

  internal_addtest(elem, i, realret);
}

void delpostest(int i)
{
  int index = i;
  void *elem = array[i], *ret;

  /* i points to the right element */
  while (i < arraylen - 1) {
    array[i] = array[i + 1];
    i++;
  }
  arraylen--; /* delete elem from array */

  if (tree->cmp)
    ret = del234(tree, elem);
  else
    ret = delpos234(tree, index);

  if (ret != elem) {
    error("del returned %p, expected %p", ret, elem);
  }

  verify();
}

void deltest(void *elem)
{
  int i;

  i = 0;
  while (i < arraylen && cmp(elem, array[i]) > 0)
    i++;
  if (i >= arraylen || cmp(elem, array[i]) != 0)
    return; /* don't do it! */
  delpostest(i);
}

/* A sample data set and test utility. Designed for pseudo-randomness,
 * and yet repeatability. */

/*
 * This random number generator uses the `portable implementation'
 * given in ANSI C99 draft N869. It assumes `unsigned' is 32 bits;
 * change it if not.
 */
int randomnumber(unsigned *seed)
{
  *seed *= 1103515245;
  *seed += 12345;
  return ((*seed) / 65536) % 32768;
}

int mycmp(void *av, void *bv)
{
  char const *a = (char const *)av;
  char const *b = (char const *)bv;
  return strcmp(a, b);
}

#define lenof(x) (sizeof((x)) / sizeof(*(x)))

char *strings[] = {"a",       "ab",         "absque",    "coram",    "de",
                   "palam",   "clam",       "cum",       "ex",       "e",
                   "sine",    "tenus",      "pro",       "prae",     "banana",
                   "carrot",  "cabbage",    "broccoli",  "onion",    "zebra",
                   "penguin", "blancmange", "pangolin",  "whale",    "hedgehog",
                   "giraffe", "peanut",     "bungee",    "foo",      "bar",
                   "baz",     "quux",       "murfl",     "spoo",     "breen",
                   "flarn",   "octothorpe", "snail",     "tiger",    "elephant",
                   "octopus", "warthog",    "armadillo", "aardvark", "wyvern",
                   "dragon",  "elf",        "dwarf",     "orc",      "goblin",
                   "pixie",   "basilisk",   "warg",      "ape",      "lizard",
                   "newt",    "shopkeeper", "wand",      "ring",     "amulet"};

#define NSTR lenof(strings)

int findtest(void)
{
  const static int rels[] = {
      REL234_EQ, REL234_GE, REL234_LE, REL234_LT, REL234_GT};
  const static char *const relnames[] = {"EQ", "GE", "LE", "LT", "GT"};
  int i, j, rel, index;
  char *p, *ret, *realret, *realret2;
  int lo, hi, mid, c;

  for (i = 0; i < NSTR; i++) {
    p = strings[i];
    for (j = 0; j < sizeof(rels) / sizeof(*rels); j++) {
      rel = rels[j];

      lo = 0;
      hi = arraylen - 1;
      while (lo <= hi) {
        mid = (lo + hi) / 2;
        c = strcmp(p, array[mid]);
        if (c < 0)
          hi = mid - 1;
        else if (c > 0)
          lo = mid + 1;
        else
          break;
      }

      if (c == 0) {
        if (rel == REL234_LT)
          ret = (mid > 0 ? array[--mid] : NULL);
        else if (rel == REL234_GT)
          ret = (mid < arraylen - 1 ? array[++mid] : NULL);
        else
          ret = array[mid];
      } else {
        assert(lo == hi + 1);
        if (rel == REL234_LT || rel == REL234_LE) {
          mid = hi;
          ret = (hi >= 0 ? array[hi] : NULL);
        } else if (rel == REL234_GT || rel == REL234_GE) {
          mid = lo;
          ret = (lo < arraylen ? array[lo] : NULL);
        } else
          ret = NULL;
      }

      realret = findrelpos234(tree, p, NULL, rel, &index);
      if (realret != ret) {
        error("find(\"%s\",%s) gave %s should be %s",
              p,
              relnames[j],
              realret,
              ret);
      }
      if (realret && index != mid) {
        error(
            "find(\"%s\",%s) gave %d should be %d", p, relnames[j], index, mid);
      }
      if (realret && rel == REL234_EQ) {
        realret2 = index234(tree, index);
        if (realret2 != realret) {
          error("find(\"%s\",%s) gave %s(%d) but %d -> %s",
                p,
                relnames[j],
                realret,
                index,
                index,
                realret2);
        }
      }
#if 0
	    printf("find(\"%s\",%s) gave %s(%d)\n", p, relnames[j],
		   realret, index);
#endif
    }
  }

  realret = findrelpos234(tree, NULL, NULL, REL234_GT, &index);
  if (arraylen && (realret != array[0] || index != 0)) {
    error(
        "find(NULL,GT) gave %s(%d) should be %s(0)", realret, index, array[0]);
  } else if (!arraylen && (realret != NULL)) {
    error("find(NULL,GT) gave %s(%d) should be NULL", realret, index);
  }

  realret = findrelpos234(tree, NULL, NULL, REL234_LT, &index);
  if (arraylen && (realret != array[arraylen - 1] || index != arraylen - 1)) {
    error("find(NULL,LT) gave %s(%d) should be %s(0)",
          realret,
          index,
          array[arraylen - 1]);
  } else if (!arraylen && (realret != NULL)) {
    error("find(NULL,LT) gave %s(%d) should be NULL", realret, index);
  }
}

int main(void)
{
  int in[NSTR];
  int i, j, k;
  unsigned seed = 0;

  for (i = 0; i < NSTR; i++)
    in[i] = 0;
  array = NULL;
  arraylen = arraysize = 0;
  tree = newtree234(mycmp);
  cmp = mycmp;

  verify();
  for (i = 0; i < 10000; i++) {
    j = randomnumber(&seed);
    j %= NSTR;
    printf("trial: %d\n", i);
    if (in[j]) {
      printf("deleting %s (%d)\n", strings[j], j);
      deltest(strings[j]);
      in[j] = 0;
    } else {
      printf("adding %s (%d)\n", strings[j], j);
      addtest(strings[j]);
      in[j] = 1;
    }
    findtest();
  }

  while (arraylen > 0) {
    j = randomnumber(&seed);
    j %= arraylen;
    deltest(array[j]);
  }

  freetree234(tree);

  /*
   * Now try an unsorted tree. We don't really need to test
   * delpos234 because we know del234 is based on it, so it's
   * already been tested in the above sorted-tree code; but for
   * completeness we'll use it to tear down our unsorted tree
   * once we've built it.
   */
  tree = newtree234(NULL);
  cmp = NULL;
  verify();
  for (i = 0; i < 1000; i++) {
    printf("trial: %d\n", i);
    j = randomnumber(&seed);
    j %= NSTR;
    k = randomnumber(&seed);
    k %= count234(tree) + 1;
    printf("adding string %s at index %d\n", strings[j], k);
    addpostest(strings[j], k);
  }
  while (count234(tree) > 0) {
    printf("cleanup: tree size %d\n", count234(tree));
    j = randomnumber(&seed);
    j %= count234(tree);
    printf("deleting string %s from index %d\n", (const char *)array[j], j);
    delpostest(j);
  }

  return 0;
}

#endif
